package test3.dao.impl;

import test3.bean.Employee;
import test3.bean.EmployeeForQuery;
import test3.dao.EmployeeDao;
import test3.file.FileModel;
import test3.runexception.MinBeyondMaxExption;

import java.io.IOException;
import java.util.*;
import java.util.stream.Stream;


/**
 * 这是一个单例的dao类 保证数据源只会生成一个，只会生成一次
 */
public class EmployeeDaoImpl implements EmployeeDao {

    //保存的所有员工的信息的键值集合
    private Map<Integer,Employee>employeeMap=null;
    //将要返回的单例对象
    private static EmployeeDaoImpl dao=new EmployeeDaoImpl();
    //文件操作的对象
    private FileModel model;
    //一个私有的构造器
    private EmployeeDaoImpl(){
            model=new FileModel();
            employeeMap=model.inputAllEmployee();
    }

    /**
     * 返回一个单例的dao实例
     * @return EmployeeDaoImpl 一个单例
     */
    public static EmployeeDaoImpl createEmployeeDao(){
        if (dao==null){
            dao=new EmployeeDaoImpl();
        }
        return dao;
    }


    /**
     * 会出现空指针异常
     * @param e 员工的信息
     */
    @Override
    public void insertOrUpdate(Employee e) {
        if (e!=null) {
            employeeMap.put(e.getId(), e);
            try {
                model.outputAllEmployee(employeeMap);
            } catch (IOException e1) {
                e1.printStackTrace();
            }
        }
        else
            throw new NullPointerException();
    }

    @Override
    public void insert(List<Employee> es) {
        if (es!=null && es.size()>0) {
            Iterator<Employee> iterator = es.iterator();
            while (iterator.hasNext()) {
                Employee e = iterator.next();
                employeeMap.put(e.getId(), e);
            }
        }
    }

    @Override
    public void delete(int id) {
        if (employeeMap.keySet().contains(id)){
            employeeMap.remove(id);
            try {
                model.outputAllEmployee(employeeMap);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Override
    public List<Employee> queryAllByList() {

        Iterator<Employee> iterator = getEmployeeIterator();
        //返回的数据的集合
        List<Employee> e=new ArrayList<>();

        while (iterator.hasNext()){
            e.add(iterator.next());
        }

        return e;
    }

    @Override
    public List<Employee> queryByRequre(EmployeeForQuery ee) {
        //得到已一个所有员工信息的迭代器
        Iterator<Employee> iterator = getEmployeeIterator();
        //得到了员工查询条件的信息
        String name=ee.getName();
        Integer sex=ee.getSex();
        Integer minAge=ee.getMinAge()==null ? 0:ee.getMinAge();
        Integer maxAge=ee.getMaxAge()==null ? 108:ee.getMaxAge();

        //如果查询的年龄最大值小于最小值会抛出异常
        if (minAge>maxAge){
            Integer temp=minAge;
            minAge=maxAge;
            maxAge=temp;
            throw new MinBeyondMaxExption("最小年龄不能大于最大年龄");
        }

        //装已经查询到的数据的结果集，需要返回的数据的集合
        List<Employee> e=null;
        //中间承接的集合
        List<Employee>eTemp=new ArrayList<>();

        //如果查询条件的名字不为空，查找所有名字为name的数据
        if (name!=null && iterator.hasNext()) {
            while (iterator.hasNext()) {
                //得到下一个员工信息
                Employee employee = iterator.next();
                //如果员工的名字等于name，加入集合
                if (employee.getName().equals(name)) {
                    eTemp.add(employee);
                }
            }
            //将结果的引用给结果集合
            e=eTemp;
        }

        //如果查询条件的性别不为空，且 已经查询到的查询结果的集合size大于0
        if (sex!=null && e.size()>0){
            //得到已经查询到的结果集合的迭代器
            iterator=e.iterator();
            //新的承接数据的集合
            eTemp=new ArrayList<>();
            //遍历查找
            while (iterator.hasNext()){
                Employee employee=iterator.next();
                if (sex.equals(employee.getSex())){
                    eTemp.add(employee);
                }
            }
            //将结果的引用给结果集合
            e=eTemp;
        }

        //查询的结果集的尺寸大于0
        if (e.size()>0){
            iterator = e.iterator();
            eTemp=new ArrayList<>();
            //遍历查找到所有年龄满足情况的结果
            while (iterator.hasNext()){
                Employee employee=iterator.next();
                Integer age=employee.getAge();
                if (age<maxAge && age> minAge){
                    eTemp.add(employee);
                }
            }
            e=eTemp;
        }

        if (e.size()==0)
            e=null;

        return e;
    }

    @Override
    public Employee queryById(Integer id) {
        return employeeMap.get(id);
    }

    @Override
    public Map<Integer, Employee> getMap() {
        return employeeMap;
    }

    private Iterator<Employee> getEmployeeIterator(){
        //读取关系集中中所有map的值集合
        Collection<Employee> employees=  employeeMap.values();
        //读取集合的迭代器
        Iterator<Employee> iterator = employees.iterator();

        return iterator;
    }
}
